home *** CD-ROM | disk | FTP | other *** search
/ Collection of Internet / Collection of Internet.iso / msdos / lynx / source / www / library / implemen / htbtree.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-25  |  25.7 KB  |  715 lines
  1. /*                  Binary Tree for sorting things
  2. **                  ==============================
  3. **                      Author: Arthur Secret
  4. **
  5. **       4 March 94: Bug fixed in the balancing procedure
  6. **
  7. */
  8. #include"capstdio.h"
  9. #include"capalloc.h"
  10. #include "HTUtils.h"
  11. #include "HTBTree.h"
  12. #include <stdlib.h>
  13. #include <string.h>
  14.  
  15. #define MAXIMUM(a,b) ((a)>(b)?(a):(b))
  16.  
  17.  
  18.  
  19.  
  20.  
  21. PUBLIC HTBTree * HTBTree_new ARGS1(HTComparer, comp)
  22.     /*********************************************************
  23.     ** This function returns an HTBTree with memory allocated
  24.     ** for it when given a mean to compare things
  25.     */
  26. {
  27.     HTBTree * tree = (HTBTree *)malloc(sizeof(HTBTree));
  28.     if (tree==NULL) outofmem(__FILE__, "HTBTree_new");
  29.  
  30.     tree->compare = comp;
  31.     tree->top = NULL;
  32.  
  33.     return tree;
  34. }
  35.  
  36.  
  37.  
  38.  
  39. PRIVATE void HTBTElement_free ARGS1(HTBTElement*, element)
  40.     /**********************************************************
  41.     ** This void will free the memory allocated for one element
  42.     */
  43. {
  44.     if (element) {
  45.     if (element->left != NULL)    HTBTElement_free(element->left);
  46.     if (element->right != NULL)    HTBTElement_free(element->right);
  47.     free(element);
  48.     }
  49. }
  50.  
  51. PUBLIC void HTBTree_free ARGS1(HTBTree*, tree)
  52.     /**************************************************************
  53.     ** This void will free the memory allocated for the whole tree
  54.     */
  55. {
  56.     HTBTElement_free(tree->top);
  57.     free(tree);
  58. }
  59.  
  60.  
  61.  
  62.  
  63. PRIVATE void HTBTElementAndObject_free ARGS1(HTBTElement*, element)
  64.     /**********************************************************
  65.     ** This void will free the memory allocated for one element
  66.     */
  67. {
  68.     if (element) {     /* Just in case nothing was in the tree anyway */
  69.     if (element->left != NULL)    HTBTElementAndObject_free(element->left);
  70.     if (element->right != NULL)
  71.         HTBTElementAndObject_free(element->right);
  72.     free(element->object);
  73.     free(element);
  74.     }
  75. }
  76.  
  77. PUBLIC void HTBTreeAndObject_free ARGS1(HTBTree*, tree)
  78.     /**************************************************************
  79.     ** This void will free the memory allocated for the whole tree
  80.     */
  81. {
  82.     HTBTElementAndObject_free(tree->top);
  83.     free(tree);
  84. }
  85.  
  86.  
  87.  
  88.  
  89. PUBLIC void HTBTree_add ARGS2(
  90.             HTBTree*,  tree,
  91.             void*,     object)
  92.     /**********************************************************************
  93.     ** This void is the core of HTBTree.c . It will
  94.     **       1/ add a new element to the tree at the right place
  95.     **          so that the tree remains sorted
  96.     **       2/ balance the tree to be as fast as possible when reading it
  97.     */
  98. {
  99.     HTBTElement * father_of_element;
  100.     HTBTElement * added_element;
  101.     HTBTElement * forefather_of_element;
  102.     HTBTElement * father_of_forefather;
  103.     BOOL father_found,top_found;
  104.     int depth,depth2,corrections;
  105.     /* father_of_element is a pointer to the structure that is the father of the
  106.     ** new object "object".
  107.     ** added_element is a pointer to the structure that contains or will contain
  108.     ** the new object "object".
  109.     ** father_of_forefather and forefather_of_element are pointers that are used
  110.     ** to modify the depths of upper elements, when needed.
  111.     **
  112.     ** father_found indicates by a value NO when the future father of "object"
  113.     ** is found.
  114.     ** top_found indicates by a value NO when, in case of a difference of depths
  115.     **  < 2, the top of the tree is encountered and forbids any further try to
  116.     ** balance the tree.
  117.     ** corrections is an integer used to avoid infinite loops in cases
  118.     ** such as:
  119.     **
  120.     **             3                        3
  121.     **          4                              4
  122.     **           5                            5
  123.     **
  124.     ** 3 is used here to show that it need not be the top of the tree.
  125.     */
  126.  
  127.     /*
  128.     ** 1/ Adding of the element to the binary tree
  129.     */
  130.  
  131.     if (tree->top == NULL)
  132.     {
  133.     tree->top = (HTBTElement *)malloc(sizeof(HTBTElement));
  134.     if (tree->top == NULL) outofmem(__FILE__, "HTBTree_add");
  135.     tree->top->up = NULL;
  136.     tree->top->object = object;
  137.     tree->top->left = NULL;
  138.     tree->top->left_depth = 0;
  139.     tree->top->right = NULL;
  140.     tree->top->right_depth = 0;
  141.     }
  142.     else
  143.     {
  144.     father_found = YES;
  145.     father_of_element = tree->top;
  146.     added_element = NULL;
  147.     father_of_forefather = NULL;
  148.     forefather_of_element = NULL;
  149.     while (father_found)
  150.     {
  151.         if (tree->compare(object,father_of_element->object)<0)
  152.         {
  153.         if (father_of_element->left != NULL)
  154.             father_of_element = father_of_element->left;
  155.         else
  156.         {
  157.             father_found = NO;
  158.             father_of_element->left =
  159.             (HTBTElement *)malloc(sizeof(HTBTElement));
  160.             if (father_of_element->left==NULL)
  161.             outofmem(__FILE__, "HTBTree_add");
  162.             added_element = father_of_element->left;
  163.             added_element->up = father_of_element;
  164.             added_element->object = object;
  165.             added_element->left = NULL;
  166.             added_element->left_depth = 0;
  167.             added_element->right = NULL;
  168.             added_element->right_depth = 0;
  169.         }
  170.         }
  171.         if (tree->compare(object,father_of_element->object)>=0)
  172.         {
  173.         if (father_of_element->right != NULL)
  174.             father_of_element = father_of_element->right;
  175.         else
  176.         {
  177.             father_found = NO;
  178.             father_of_element->right =
  179.             (HTBTElement *)malloc(sizeof(HTBTElement));
  180.             if (father_of_element->right==NULL)
  181.             outofmem(__FILE__, "HTBTree_add");
  182.             added_element = father_of_element->right;
  183.             added_element->up = father_of_element;
  184.             added_element->object = object;
  185.             added_element->left = NULL;
  186.             added_element->left_depth = 0;
  187.             added_element->right = NULL;
  188.             added_element->right_depth = 0;
  189.         }
  190.         }
  191.     }
  192.         /*
  193.         ** Changing of all depths that need to be changed
  194.         */
  195.     father_of_forefather = father_of_element;
  196.     forefather_of_element = added_element;
  197.     do
  198.     {
  199.         if (father_of_forefather->left == forefather_of_element)
  200.         {
  201.         depth = father_of_forefather->left_depth;
  202.         father_of_forefather->left_depth = 1
  203.                 + MAXIMUM(forefather_of_element->right_depth,
  204.                   forefather_of_element->left_depth);
  205.         depth2 = father_of_forefather->left_depth;
  206.         }
  207.         else
  208.         {
  209.         depth = father_of_forefather->right_depth;
  210.         father_of_forefather->right_depth = 1
  211.                 + MAXIMUM(forefather_of_element->right_depth,
  212.                   forefather_of_element->left_depth);
  213.         depth2 = father_of_forefather->right_depth;
  214.         }
  215.         forefather_of_element = father_of_forefather;
  216.         father_of_forefather = father_of_forefather->up;
  217.     } while ((depth != depth2) && (father_of_forefather != NULL));
  218.  
  219.  
  220.  
  221.         /*
  222.         ** 2/ Balancing the binary tree, if necessary
  223.         */
  224.     top_found = YES;
  225.     corrections = 0;
  226.     while ((top_found) && (corrections < 7))
  227.     {
  228.         if ((abs(father_of_element->left_depth
  229.               - father_of_element->right_depth)) < 2)
  230.         {
  231.         if (father_of_element->up != NULL)
  232.             father_of_element = father_of_element->up;
  233.         else top_found = NO;
  234.         }
  235.             else
  236.          {                /* We start the process of balancing */
  237.  
  238.                 corrections = corrections + 1;
  239.                     /* 
  240.                     ** corrections is an integer used to avoid infinite 
  241.                     ** loops in cases such as:
  242.                     **
  243.                     **             3                        3
  244.                     **          4                              4
  245.                     **           5                            5
  246.                     **
  247.                     ** 3 is used to show that it need not be the top of the tree
  248.             ** But let's avoid these two exceptions anyhow 
  249.             ** with the two following conditions (4 March 94 - AS)
  250.                     */
  251.  
  252.         if ((father_of_element->left == NULL) 
  253.             && (father_of_element->right->right == NULL) 
  254.             && (father_of_element->right->left->left == NULL) 
  255.             && (father_of_element->right->left->right == NULL)) 
  256.             corrections = 7;
  257.  
  258.         if ((father_of_element->right == NULL) 
  259.             && (father_of_element->left->left == NULL) 
  260.             && (father_of_element->left->right->right == NULL) 
  261.             && (father_of_element->left->right->left == NULL))
  262.             corrections = 7;
  263.  
  264.  
  265.                 if (father_of_element->left_depth > father_of_element->right_depth)
  266.             {
  267.                     added_element = father_of_element->left;
  268.                     father_of_element->left_depth = added_element->right_depth;
  269.                     added_element->right_depth = 1
  270.                                     + MAXIMUM(father_of_element->right_depth,
  271.                                           father_of_element->left_depth);
  272.                     if (father_of_element->up != NULL)
  273.             {
  274.             /* Bug fixed in March 94  -  AS */
  275.             BOOL first_time;
  276.  
  277.                         father_of_forefather = father_of_element->up;
  278.                         forefather_of_element = added_element;
  279.             first_time = YES;
  280.                         do 
  281.                         {
  282.                             if (father_of_forefather->left
  283.                                  == forefather_of_element->up)
  284.                               {
  285.                   depth = father_of_forefather->left_depth;
  286.                   if (first_time)
  287.                   {
  288.                       father_of_forefather->left_depth = 1
  289.                       + MAXIMUM(forefather_of_element->left_depth,
  290.                           forefather_of_element->right_depth);
  291.                     first_time = NO;
  292.                    }
  293.                    else
  294.                        father_of_forefather->left_depth = 1
  295.                        + MAXIMUM(forefather_of_element->up->left_depth,
  296.                           forefather_of_element->up->right_depth);
  297.  
  298.                                 depth2 = father_of_forefather->left_depth;
  299.                 }
  300.                             else
  301.                 {
  302.                                 depth = father_of_forefather->right_depth;
  303.                 if (first_time)
  304.                 {
  305.                     father_of_forefather->right_depth = 1
  306.                       + MAXIMUM(forefather_of_element->left_depth,
  307.                            forefather_of_element->right_depth);
  308.                     first_time = NO;
  309.                 }                
  310.                 else
  311.                     father_of_forefather->right_depth = 1
  312.                       + MAXIMUM(forefather_of_element->up->left_depth,
  313.                        forefather_of_element->up->right_depth);
  314.                                 depth2 = father_of_forefather->right_depth;
  315.                 }
  316.                             forefather_of_element = forefather_of_element->up;
  317.                             father_of_forefather = father_of_forefather->up;
  318.             } while ((depth != depth2) && 
  319.                  (father_of_forefather != NULL));
  320.                         father_of_forefather = father_of_element->up;
  321.                         if (father_of_forefather->left == father_of_element)
  322.                     {
  323.                             /*
  324.                             **                   3                       3
  325.                             **               4                       5
  326.                             ** When tree   5   6        becomes    7    4
  327.                             **            7 8                          8 6
  328.                             **
  329.                             ** 3 is used to show that it may not be the top of the
  330.                             ** tree.
  331.                             */ 
  332.                             father_of_forefather->left = added_element;
  333.                             father_of_element->left = added_element->right;
  334.                             added_element->right = father_of_element;
  335.                         }
  336.                         if (father_of_forefather->right == father_of_element)
  337.                 {
  338.                             /*
  339.                             **          3                       3
  340.                             **               4                       5
  341.                             ** When tree   5   6        becomes    7    4
  342.                             **            7 8                          8 6
  343.                             **
  344.                             ** 3 is used to show that it may not be the top of the
  345.                             ** tree
  346.                             */
  347.                             father_of_forefather->right = added_element;
  348.                             father_of_element->left = added_element->right;
  349.                             added_element->right = father_of_element;
  350.                         }
  351.                         added_element->up = father_of_forefather;
  352.             }
  353.                     else
  354.             {
  355.                         /*
  356.                         **
  357.                         **               1                       2
  358.                         ** When tree   2   3        becomes    4    1
  359.                         **            4 5                          5 3
  360.                         **
  361.                         ** 1 is used to show that it is the top of the tree    
  362.                         */
  363.                         added_element->up = NULL;
  364.                         father_of_element->left = added_element->right;
  365.                         added_element->right = father_of_element;
  366.             }
  367.                     father_of_element->up = added_element;
  368.                     if (father_of_element->left != NULL)
  369.                         father_of_element->left->up = father_of_element;
  370.             }
  371.                 else
  372.             {
  373.                     added_element = father_of_element->right;
  374.                     father_of_element->right_depth = added_element->left_depth;
  375.                     added_element->left_depth = 1 + 
  376.                             MAXIMUM(father_of_element->right_depth,
  377.                                 father_of_element->left_depth);
  378.                     if (father_of_element->up != NULL)
  379.             /* Bug fixed in March 94  -  AS */
  380.             {
  381.             BOOL first_time;
  382.  
  383.                         father_of_forefather = father_of_element->up;
  384.                         forefather_of_element = added_element;
  385.             first_time = YES;
  386.                         do 
  387.                         {
  388.                             if (father_of_forefather->left 
  389.                 == forefather_of_element->up)
  390.                             {
  391.                                 depth = father_of_forefather->left_depth;
  392.                                 if (first_time)
  393.                 {
  394.                     father_of_forefather->left_depth = 1
  395.                        + MAXIMUM(forefather_of_element->left_depth,
  396.                            forefather_of_element->right_depth);
  397.                     first_time = NO;
  398.                 }
  399.                                 else
  400.                     father_of_forefather->left_depth = 1
  401.                       + MAXIMUM(forefather_of_element->up->left_depth,
  402.                              forefather_of_element->up->right_depth);
  403.                 depth2 = father_of_forefather->left_depth;
  404.                 }
  405.                             else
  406.                 {
  407.                                 depth = father_of_forefather->right_depth;
  408.                 if (first_time)
  409.                 {
  410.                     father_of_forefather->right_depth = 1
  411.                        + MAXIMUM(forefather_of_element->left_depth,
  412.                            forefather_of_element->right_depth);
  413.                     first_time = NO;
  414.                 }
  415.                 else
  416.                     father_of_forefather->right_depth = 1
  417.                       + MAXIMUM(forefather_of_element->up->left_depth,
  418.                        forefather_of_element->up->right_depth);
  419.                                 depth2 = father_of_forefather->right_depth;
  420.                 }
  421.                             father_of_forefather = father_of_forefather->up;
  422.                             forefather_of_element = forefather_of_element->up;
  423.             } while ((depth != depth2) && 
  424.                  (father_of_forefather != NULL));
  425.                         father_of_forefather = father_of_element->up;
  426.                         if (father_of_forefather->left == father_of_element)
  427.                 {
  428.                             /*
  429.                             **                    3                       3
  430.                             **               4                       6
  431.                             ** When tree   5   6        becomes    4    8
  432.                             **                7 8                 5 7
  433.                             **
  434.                             ** 3 is used to show that it may not be the top of the
  435.                             ** tree.
  436.                             */
  437.                             father_of_forefather->left = added_element;
  438.                             father_of_element->right = added_element->left;
  439.                             added_element->left = father_of_element;
  440.                         }
  441.                         if (father_of_forefather->right == father_of_element)
  442.                 {
  443.                             /*
  444.                             **           3                      3
  445.                             **               4                       6
  446.                             ** When tree   5   6        becomes    4    8
  447.                             **                7 8                 5 7
  448.                             **
  449.                             ** 3 is used to show that it may not be the top of the
  450.                             ** tree
  451.                             */
  452.                             father_of_forefather->right = added_element;
  453.                             father_of_element->right = added_element->left;
  454.                             added_element->left = father_of_element;
  455.                         }
  456.                         added_element->up = father_of_forefather;
  457.             }
  458.                     else
  459.                     {
  460.                         /*
  461.                         **
  462.                         **               1                       3
  463.                         ** When tree   2   3        becomes    1    5
  464.                         **                4 5                 2 4
  465.                         **
  466.                         ** 1 is used to show that it is the top of the tree.
  467.                         */
  468.                         added_element->up = NULL;
  469.                         father_of_element->right = added_element->left;
  470.                         added_element->left = father_of_element;
  471.             }
  472.                     father_of_element->up = added_element;
  473.                     if (father_of_element->right != NULL)
  474.                 father_of_element->right->up = father_of_element;
  475.         }
  476.         }
  477.         }
  478.         while (father_of_element->up != NULL)
  479.     {
  480.             father_of_element = father_of_element->up;
  481.         }
  482.         tree->top = father_of_element;
  483.     }
  484. }
  485.  
  486.  
  487.  
  488. PUBLIC HTBTElement * HTBTree_next ARGS2(
  489.                                HTBTree*,       tree,
  490.                                HTBTElement*,   ele)
  491.     /**************************************************************************
  492.     ** this function returns a pointer to the leftmost element if ele is NULL,
  493.     ** and to the next object to the right otherways.
  494.     ** If no elements left, returns a pointer to NULL.
  495.     */
  496. {
  497.     HTBTElement * father_of_element;
  498.     HTBTElement * father_of_forefather;
  499.  
  500.     if (ele == NULL)
  501.     {
  502.         father_of_element = tree->top;
  503.         if (father_of_element != NULL)
  504.             while (father_of_element->left != NULL)
  505.                 father_of_element = father_of_element->left;
  506.     }
  507.     else
  508.     {
  509.         father_of_element = ele;
  510.         if (father_of_element->right != NULL)
  511.     {
  512.             father_of_element = father_of_element->right;
  513.             while (father_of_element->left != NULL)
  514.                 father_of_element = father_of_element->left;
  515.     }
  516.         else
  517.     {
  518.             father_of_forefather = father_of_element->up;
  519.             while (father_of_forefather && 
  520.                (father_of_forefather->right == father_of_element))
  521.                   {
  522.                     father_of_element = father_of_forefather;
  523.             father_of_forefather = father_of_element->up;
  524.         }
  525.             father_of_element = father_of_forefather;
  526.     }
  527.     }
  528. #ifdef BTREE_TRACE
  529.     /* The option -DBTREE_TRACE will give much more information
  530.     ** about the way the process is running, for debugging matters
  531.     */
  532.     if (father_of_element != NULL)
  533.     {
  534.         printf("\nObject = %s\t",(char *)father_of_element->object);
  535.         if (father_of_element->up != NULL)
  536.             printf("Objet du pere = %s\n",
  537.            (char *)father_of_element->up->object);
  538.         else printf("Pas de Pere\n");
  539.         if (father_of_element->left != NULL)
  540.             printf("Objet du fils gauche = %s\t",
  541.            (char *)father_of_element->left->object); 
  542.         else printf("Pas de fils gauche\t");
  543.         if (father_of_element->right != NULL)
  544.             printf("Objet du fils droit = %s\n",
  545.            (char *)father_of_element->right->object);
  546.         else printf("Pas de fils droit\n");
  547.         printf("Profondeur gauche = %i\t",father_of_element->left_depth);
  548.         printf("Profondeur droite = %i\n",father_of_element->right_depth);
  549.         printf("      **************\n");
  550.     }
  551. #endif
  552.     return father_of_element;
  553. }
  554.  
  555.  
  556. #ifdef TEST
  557. main ()
  558.     /******************************************************
  559.     ** This is just a test to show how to handle HTBTree.c
  560.     */
  561. {
  562.     HTBTree * tree;
  563.     HTBTElement * next_element;
  564.     
  565.     tree = HTBTree_new((HTComparer)strcasecmp);
  566.     HTBTree_add(tree,"hypertext");
  567.     HTBTree_add(tree,"Addressing");
  568.     HTBTree_add(tree,"X11");
  569.     HTBTree_add(tree,"Tools");
  570.     HTBTree_add(tree,"Proposal.wn");
  571.     HTBTree_add(tree,"Protocols");
  572.     HTBTree_add(tree,"NeXT");
  573.     HTBTree_add(tree,"Daemon");
  574.     HTBTree_add(tree,"Test");
  575.     HTBTree_add(tree,"Administration");
  576.     HTBTree_add(tree,"LineMode");
  577.     HTBTree_add(tree,"DesignIssues");
  578.     HTBTree_add(tree,"MarkUp");
  579.     HTBTree_add(tree,"Macintosh");
  580.     HTBTree_add(tree,"Proposal.rtf.wn");
  581.     HTBTree_add(tree,"FIND");
  582.     HTBTree_add(tree,"Paper");
  583.     HTBTree_add(tree,"Tcl");
  584.     HTBTree_add(tree,"Talks");
  585.     HTBTree_add(tree,"Architecture");
  586.     HTBTree_add(tree,"VMSHelp");
  587.     HTBTree_add(tree,"Provider");
  588.     HTBTree_add(tree,"Archive");
  589.     HTBTree_add(tree,"SLAC");
  590.     HTBTree_add(tree,"Project");
  591.     HTBTree_add(tree,"News");
  592.     HTBTree_add(tree,"Viola");
  593.     HTBTree_add(tree,"Users");
  594.     HTBTree_add(tree,"FAQ");
  595.     HTBTree_add(tree,"WorkingNotes");
  596.     HTBTree_add(tree,"Windows");
  597.     HTBTree_add(tree,"FineWWW");
  598.     HTBTree_add(tree,"Frame");
  599.     HTBTree_add(tree,"XMosaic");
  600.     HTBTree_add(tree,"People");
  601.     HTBTree_add(tree,"All");
  602.     HTBTree_add(tree,"Curses");
  603.     HTBTree_add(tree,"Erwise");
  604.     HTBTree_add(tree,"Carl");
  605.     HTBTree_add(tree,"MidasWWW");
  606.     HTBTree_add(tree,"XPM");
  607.     HTBTree_add(tree,"MailRobot");
  608.     HTBTree_add(tree,"Illustrations");
  609.     HTBTree_add(tree,"VMClient");
  610.     HTBTree_add(tree,"XPA");
  611.     HTBTree_add(tree,"Clients.html");
  612.     HTBTree_add(tree,"Library");
  613.     HTBTree_add(tree,"CERNLIB_Distribution");
  614.     HTBTree_add(tree,"libHTML");
  615.     HTBTree_add(tree,"WindowsPC");
  616.     HTBTree_add(tree,"tkWWW");
  617.     HTBTree_add(tree,"tk2.3");
  618.     HTBTree_add(tree,"CVS-RCS");
  619.     HTBTree_add(tree,"DecnetSockets");
  620.     HTBTree_add(tree,"SGMLStream");
  621.     HTBTree_add(tree,"NextStep");
  622.     HTBTree_add(tree,"CVSRepository_old");
  623.     HTBTree_add(tree,"ArthurSecret");
  624.     HTBTree_add(tree,"CVSROOT");
  625.     HTBTree_add(tree,"HytelnetGate");
  626.     HTBTree_add(tree,"cern.www.new.src");
  627.     HTBTree_add(tree,"Conditions");
  628.     HTBTree_add(tree,"HTMLGate");
  629.     HTBTree_add(tree,"Makefile");
  630.     HTBTree_add(tree,"Newsgroups.html");
  631.     HTBTree_add(tree,"People.html");
  632.     HTBTree_add(tree,"Bugs.html");
  633.     HTBTree_add(tree,"Summary.html");
  634.     HTBTree_add(tree,"zDesignIssues.wn");
  635.     HTBTree_add(tree,"HT.draw");
  636.     HTBTree_add(tree,"HTandCERN.wn");
  637.     HTBTree_add(tree,"Ideas.wn");
  638.     HTBTree_add(tree,"MarkUp.wn");
  639.     HTBTree_add(tree,"Proposal.html");
  640.     HTBTree_add(tree,"SearchPanel.draw");
  641.     HTBTree_add(tree,"Comments.wn");
  642.     HTBTree_add(tree,"Xanadu.html");
  643.     HTBTree_add(tree,"Storinglinks.html");
  644.     HTBTree_add(tree,"TheW3Book.html");
  645.     HTBTree_add(tree,"Talk_Feb-91.html");
  646.     HTBTree_add(tree,"JFosterEntry.txt");
  647.     HTBTree_add(tree,"Summary.txt");
  648.     HTBTree_add(tree,"Bibliography.html");
  649.     HTBTree_add(tree,"HTandCern.txt");
  650.     HTBTree_add(tree,"Talk.draw");
  651.     HTBTree_add(tree,"zDesignNotes.html");
  652.     HTBTree_add(tree,"Link.html");
  653.     HTBTree_add(tree,"Status.html");
  654.     HTBTree_add(tree,"http.txt");
  655.     HTBTree_add(tree,"People.html~");
  656.     HTBTree_add(tree,"TAGS");
  657.     HTBTree_add(tree,"summary.txt");
  658.     HTBTree_add(tree,"Technical.html");
  659.     HTBTree_add(tree,"Terms.html");
  660.     HTBTree_add(tree,"JANETAccess.html");
  661.     HTBTree_add(tree,"People.txt");
  662.     HTBTree_add(tree,"README.txt");
  663.     HTBTree_add(tree,"CodingStandards.html");
  664.     HTBTree_add(tree,"Copyright.txt");
  665.     HTBTree_add(tree,"Status_old.html");
  666.     HTBTree_add(tree,"patches~");
  667.     HTBTree_add(tree,"RelatedProducts.html");
  668.     HTBTree_add(tree,"Implementation");
  669.     HTBTree_add(tree,"History.html");
  670.     HTBTree_add(tree,"Makefile.bak");
  671.     HTBTree_add(tree,"Makefile.old");
  672.     HTBTree_add(tree,"Policy.html");
  673.     HTBTree_add(tree,"WhatIs.html");
  674.     HTBTree_add(tree,"TheProject.html");
  675.     HTBTree_add(tree,"Notation.html");
  676.     HTBTree_add(tree,"Helping.html");
  677.     HTBTree_add(tree,"Cyber-WWW.sit.Hqx");
  678.     HTBTree_add(tree,"Glossary.html");
  679.     HTBTree_add(tree,"maketags.html");
  680.     HTBTree_add(tree,"IntroCS.html");
  681.     HTBTree_add(tree,"Contrib");
  682.     HTBTree_add(tree,"Help.html");
  683.     HTBTree_add(tree,"CodeManagExec");
  684.     HTBTree_add(tree,"HT-0.1draz");
  685.     HTBTree_add(tree,"Cello");
  686.     HTBTree_add(tree,"TOPUB");
  687.     HTBTree_add(tree,"BUILD");
  688.     HTBTree_add(tree,"BUILDALL");
  689.     HTBTree_add(tree,"Lynx");
  690.     HTBTree_add(tree,"ArthurLibrary");
  691.     HTBTree_add(tree,"RashtyClient");
  692.     HTBTree_add(tree,"#History.html#");
  693.     HTBTree_add(tree,"PerlServers");
  694.     HTBTree_add(tree,"modules");
  695.     HTBTree_add(tree,"NCSA_httpd");
  696.     HTBTree_add(tree,"MAIL2HTML");
  697.     HTBTree_add(tree,"core");
  698.     HTBTree_add(tree,"EmacsWWW");
  699. #ifdef BTREE_TRACE
  700.     printf("\nTreeTopObject=%s\n\n",tree->top->object);
  701. #endif
  702.     next_element = HTBTree_next(tree,NULL);
  703.     while (next_element != NULL)
  704.     {
  705. #ifndef BTREE_TRACE
  706.         printf("The next element is %s\n",next_element->object);
  707. #endif
  708.         next_element = HTBTree_next(tree,next_element);
  709.     }
  710.     HTBTree_free (tree);
  711. }
  712.  
  713.  
  714. #endif
  715.